
Here a few commands if you want to get a list of git commit information.

This will list all the commits by the contributor.

```
git log --author="Contributor's name"
```

Get commit from **19 April 2020**.

```
git shortlog -s -n --since="19 April 2020"
```

Get commit for the contributor since 19 April 2020.

```
git log --author="Your contributor" --oneline --since="19 April 2020"
```

Same commit log but make it pretty print.

```
git log --pretty="%C(Yellow)%h  %C(reset)%ad (%C(Green)%cr%C(reset))%x09 %C(Cyan)%an: %C(reset)%s" --author="contributor" --since="19 May 2020 12:00:00 AM"
```

Quit the command line by **:q.**

```
:q
```

:h for the Help command

```
:h
```


Here a few commands if you want to get a list of git commit information.

Few Useful Command for Git Log Commit


A quick note to show how to squash all git local commits into one.

A scenario will be, you've been check-in in lots of commits into your own
local branch when you ready to push them to the origin branch. You don't want
to check-in so many commits, e.g. depending on the developer, you might have
100 commits.

Here is a quick note for doing that in the command line.

First, make sure you are in the correct branch.

```
git checkout YourBranch
```

Then, use the **soft reset** to the origin branch.

```
git reset --soft origin/YourBranch
```

Now, at this moment, all your commit should become one, you just need to
check-in that commit.

If you use Visual Studio 2019, it already has a feature that you can squash
all local commits to one, however, if you still use Visual Studio 2015, you
will have to do that in the command line.


A quick note to show how to squash all git local commits into one.

How to Squash All Git Commits into One


#### Table of Contents

1. Introduction
2. The Main Branch: Squash and Merge
3. Other Cases for Main
4. The Release Branch: Fast-Forward
5. Syntax: Syncing Main to Release
6. Handling Hotpatches
7. Conclusion

### Introduction

This blog demonstrates a clean and efficient Git workflow tailored for small teams. We will focus on keeping the `main` branch history readable while ensuring the `release` branch remains a stable mirror of production.

### The Main Branch: Squash and Merge

When working on features or bugs, developers often create dozens of "work-in-progress" commits. To keep the `main` branch clean, we use the **Squash and Merge** pattern. This collapses all commits from a branch into a single, high-quality commit on `main`.

- **Feature Branches (`feature/description`):** Use this for new development.
- **Bug Branches (`bugs/description`):** Use this for fixing issues found in development.

### Other benefits

- Feature Reversion: If feature introduced a failure, squashing make it easier to revert the change.
- Simplified "Git Blame": `git blame` will point to the a feature instead of individual commit `fixed typo`
- Avoiding "Broken" Intermediate Commits: sometime in feature branch dev fixed build or unit-test, if not use squash and keep all history, main branch will contains "broken" build commits.

### Other Cases for Main

Beyond features and bugs, you might merge into `main` for:

- **Refactoring:** Code cleanup that doesn't change functionality.
- **Documentation:** Updates to README files or API docs.
- **CI/CD Updates:** Modifying GitHub Actions or deployment scripts.
- **Dependency Updates:** Merging automated PRs (like Dependabot) to keep libraries secure.

### Example: create feature branch

```
# Ensure you are on main and up to date
git checkout main
git pull origin main

# Create and switch to a new feature branch
git checkout -b feature/describe-feature
```

### The Release Branch: Fast-Forward

For small teams, we want the `release` branch to be easy to manage. We use the **Fast-Forward** pattern, which keeps all commit history identical between `main` and `release`.

**Alternative Approaches:**

- **Merge Commits:** Some teams use `--no-ff` to create a dedicated "Merge node" to show exactly when a release happened.
- **Squash to Release:** Some teams squash all of `main` into one single "Version 1.0" commit on the release branch, though this makes tracking individual changes harder.

### Syntax: Syncing Main to Release

To move your verified code from `main` to `release` using the fast-forward pattern, run:

```bash
git checkout release
git merge main --ff-only
git push origin release
```

### Conclusion
By using Squash for development and Fast-Forward for releases, your team maintains a professional, readable history that is easy to debug. Hopefully, you find this pattern helpful for your team's workflow!

A practical guide on using Squash and Fast-Forward patterns to manage a clean Git workflow.

Git Merge Patterns for Main and Release Branches


#### Table of Contents

1. Modify Package.json
2. name
3. publishConfig
4. version
5. Publish
6. Npm Login
7. Publish npm package
8. That's it

### Modify Package.json

#### `name`

```
  "name": "@keke78ui9/node-reading"
```

#### `publishConfig`

```
"publishConfig": {
    "registry": "https://npm.pkg.github.com"
},
```

#### `version`

```
"version": "1.0.6",
```

### Publish

#### Npm Login

```
npm login --scope=@NAMESPACE --auth-type=legacy --registry=https://npm.pkg.github.com
> UserName: username
> Password: token
```

#### Publish npm package

```
npm publish --access public
```

### That's it


How to Publish NPM Package to Github


So, Git, TFVC, and SVN, actually there is most source controls exist today,
like Helix VCS, Mercurial, Rational ClearCase, CVS, Kiln, Bazaar, Fossil,
Monotone, Plastic SCM, AWS CodeCommit and more. Some of them will disappear...

![Image result for disappear funny image](http://martinliebermandotcom.files.wordpress.com/2012/08/disappear-cliff.jpg)

I only list **Git**, **TFVC**,
**SVN** because I've been used these around for awhile, they're
all popular.

##
Import repositories from TFVC to Git

Based on what I have seen so far, I think it's better to just use Git
instead.


Migrate Source Code


#### Table of Contents

1. How to Use git to commit to GitHub
2. Git local commit
3. Commit to GitHub
4. Clone Git from Github
5. Clone Git origin url A then Check-in to Git origin url B
6. List of Other Command
7. List of Git command

## How to Use git to commit to GitHub

Following example is for windows enviroment and command is use windows'
Command Prompt.

First you need to setup the git's user and email, check the current user and
email by run following command.

```
> git config --list
```

If the `user.name` or `user.email`is not there, try run
following command to set username and email address.

```
> git config --global user.name "test"
> git config --global user.email "test.email"
```

Now, you're ready for git check-in locally, if you type
`git commit -m "test commit"` for commit. Type
`git log`, you'll see the log history of the git commit.

Init Git

Run this command to initialize the git.

```
> git init
```

### Git local commit

```
> git add .
```

```
> git commit -m "Initialize repository"
```

### Commit to GitHub

```
> git remote add origin {your github address}
> git push -u origin master

```

### Clone Git from Github

```
> git clone {your github address}


```

### Clone Git origin url A then Check-in to Git origin url B

```
> git clone {url A}
> delete git folder
> git remote set-url origin {url B}
> git pull {url B}
> git push -u origin master


```

In case of `Git push` doesn't work, and you tried possible solution
already, then you could also try `git push --force`, to force
update to the remote location.

### List of Other Command

```
> rmdir {folder name} /s
```

### List of Git command

  - `git config --list`

  - `git config --get remote.origin.url`

    - check current git repository's remote url

`git config --global user.name "{your name}"`
`git config --global user.email "{your email}"`
`git init` - use git for current folder
`git commit "commit message"`

`git commit -m "commit comment, message must in one line"`

`git commit --amend -m "commit message"` - append previous commit

`git remote add origin "{Github address}"`
`git push -u origin master`
`git log`
`git log --oneline` pretty view for the log
`git status`
`git checkout --{file name}`
`git diff` want to know where is the change
`git diff --cached` show what files had changed by commit
`git reset HEAD` cancel the `git add`
`git config -l`show all the git config settings
`git help config`show config help page
git merge --abort

    - undo merge


Few Commands About Use Git to Commit to GitHub


After installed following tools, you should be able to use git with visual
studio 2012.

1. Install Visual Studio 2012 update 4

2. Install Visual Studio Git Tool

3. restart visual studio

Open Team Exploer, then you'll see Git selection.

![](https://d1p0mp3f1fx0hz.cloudfront.net/_08g77sh2o.png)


This is a memo about how to use Git with Visual Studio 2012.

Category Github